#include "touchkeyboard.h"
#include <QApplication>
#include <QScreen>
#include <QDateTime>
#include <QTimer>
#include <QRegularExpression>
#include <stdexcept>
#include <QPushButton>
#include <QMap>
#include <QLabel>
#include <QFontMetrics>

TouchKeyboard::TouchKeyboard(QWidget *parent)
    : QWidget(parent)
    , m_mainLayout(nullptr)
    , m_keyboardArea(nullptr)
    , m_headerLayout(nullptr)
    , m_modeButton(nullptr)
    , m_hideButton(nullptr)
    , m_currentMode(SimpleMode)
    , m_targetInput(nullptr)
    , m_targetTextEdit(nullptr) // 初始化QTextEdit引用
    , m_targetInputInterface(nullptr) // 初始化通用文本接口引用
    , m_plainTextAdapter(nullptr)
    , m_comboBoxAdapter(nullptr)
    , m_isCapitalized(false)
    , m_isChineseMode(false)
    , m_currentPinyin("")
    , m_currentCandidates()
    , m_currentPage(0)
    , m_candidateButtons()
    , m_candidateArea(nullptr)
    , m_pinyinLabel(nullptr)
    , m_maxCandidateCount(9) // 初始化为9个候选词（根据需求修改）
    , m_enterButton(nullptr) // 初始化回车键引用
    , pinyinMap()
    , m_languageButton(nullptr) // 初始化语言切换按钮引用
    , m_isDragging(false)
    , m_dragStartPosition()
    , m_windowStartPosition()
    , m_showAnimation(nullptr)
    , m_hideAnimation(nullptr)
    , m_isHiding(false)
    , m_lastHideTime(0)
    , m_inputMonitorTimer(nullptr) // 初始化定时器
    , m_lastInputText("") // 初始化上次输入框内容
{
    setupWindowProperties();
    
    // 设置初始尺寸
    QSize initialSize = calculateKeyboardSize();
    setFixedSize(initialSize);
    
    initializeUI();
    addDropShadow();
    
    // 创建并配置输入监控定时器
    m_inputMonitorTimer = new QTimer(this);
    m_inputMonitorTimer->setInterval(100); // 100ms检查一次
    connect(m_inputMonitorTimer, &QTimer::timeout, this, &TouchKeyboard::checkInputContent);
}

TouchKeyboard::~TouchKeyboard()
{
    if (m_showAnimation) {
        m_showAnimation->deleteLater();
    }
    if (m_hideAnimation) {
        m_hideAnimation->deleteLater();
    }
    
    // 清理适配器
    if (m_plainTextAdapter) {
        delete m_plainTextAdapter;
        m_plainTextAdapter = nullptr;
    }
    if (m_comboBoxAdapter) {
        delete m_comboBoxAdapter;
        m_comboBoxAdapter = nullptr;
    }
}

void TouchKeyboard::setupWindowProperties()
{
    // 设置窗口属性
    setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
    
    // 设置自动填充背景
    setAutoFillBackground(true);
    
    // 设置最小尺寸
    setMinimumSize(400, 250);
    
    // 隐藏窗口
    hide();
}

void TouchKeyboard::addDropShadow()
{
    // 暂时禁用阴影效果以避免 Windows 分层窗口问题
    // TODO: 后续可以考虑使用 CSS 样式或其他方式实现阴影

    /*
    QGraphicsDropShadowEffect *shadowEffect = new QGraphicsDropShadowEffect(this);
    shadowEffect->setBlurRadius(20);
    shadowEffect->setColor(QColor(0, 0, 0, 100));
    shadowEffect->setOffset(0, 5);
    setGraphicsEffect(shadowEffect);
    */
}

void TouchKeyboard::initializeUI()
{
    // 创建主布局
    m_mainLayout = new QVBoxLayout(this);
    m_mainLayout->setContentsMargins(10, 10, 10, 10);
    m_mainLayout->setSpacing(5);
    
    // 创建头部布局（包含中文候选词区域和隐藏按钮）
    QWidget *headerWidget = new QWidget();
    headerWidget->setObjectName("headerWidget");
    headerWidget->setFixedHeight(50); // 设置标题栏高度为50像素
    
    // 创建标题栏拖拽提示标签
    QLabel *dragHintLabel = new QLabel("✥✥ 拖拽移动 ✥✥", headerWidget);
    dragHintLabel->setObjectName("dragHintLabel");
    dragHintLabel->setAlignment(Qt::AlignCenter);
    dragHintLabel->setCursor(Qt::SizeAllCursor); // 设置拖拽光标
    dragHintLabel->setStyleSheet(
        "QLabel {"
        "    color: #cccccc;"
        "    font-size: 14px;"
        "    font-weight: bold;"
        "    background-color: rgba(255, 255, 255, 30);"
        "    border-radius: 6px;"
        "    padding: 2px 10px;"
        "}"
        "QLabel:hover {"
        "    background-color: rgba(255, 255, 255, 50);"
        "    color: #ffffff;"
        "}"
    );
    
    // 使整个标签可接收鼠标事件
    dragHintLabel->installEventFilter(this);
    
    // 使用绝对定位将拖拽提示放在标题栏中央
    // 先设置一个初始位置和尺寸，然后在resizeEvent中调整位置
    dragHintLabel->setGeometry(0, 10, 140, 30);
    
    // 创建中文候选词区域
    m_candidateArea = new QWidget();
    m_candidateArea->setVisible(false); // 初始隐藏
    m_candidateArea->setFixedHeight(50); // 设置为标题栏高度
    
    // 创建拼音显示标签（左上角悬浮）
    m_pinyinLabel = new QLabel();
    m_pinyinLabel->setStyleSheet(
        "QLabel {"
        "    background-color: rgba(52, 73, 94, 200);"
        "    color: #ecf0f1;"
        "    border: 1px solid #34495e;"
        "    border-radius: 4px;"
        "    padding: 2px 6px;"
        "    font-size: 11px;"
        "    font-weight: bold;"
        "}"
    );
    m_pinyinLabel->setAlignment(Qt::AlignCenter);
    m_pinyinLabel->setVisible(false);
    
    // 使用绝对定位将拼音标签放在候选词区域左上角
    m_pinyinLabel->setParent(m_candidateArea);
    m_pinyinLabel->move(5, 5);
    m_pinyinLabel->resize(60, 20);
    
    // 创建候选词布局（留出拼音区域空间）
    QHBoxLayout *candidateLayout = new QHBoxLayout(m_candidateArea);
    candidateLayout->setSpacing(3);
    candidateLayout->setContentsMargins(70, 5, 5, 5); // 左边留出拼音显示区域
    
    // 动态计算可以放置的候选词数量
    calculateMaxCandidateCount();
    
    // 创建候选词按钮
    for (int i = 0; i < m_maxCandidateCount; ++i) {
        QPushButton *candidateBtn = new QPushButton();
        candidateBtn->setFixedHeight(40); // 高度较大，方便点击
        candidateBtn->setMinimumWidth(40); // 最小宽度
        candidateBtn->setStyleSheet(
            "QPushButton {"
            "    background-color: rgba(44, 62, 80, 180);"
            "    color: white;"
            "    border: 1px solid #34495e;"
            "    border-radius: 4px;"
            "    font-size: 12px;"
            "    padding: 2px 4px;"
            "}"
            "QPushButton:hover {"
            "    background-color: rgba(52, 152, 219, 200);"
            "}"
            "QPushButton:pressed {"
            "    background-color: rgba(41, 128, 185, 220);"
            "}"
        );
        candidateBtn->setVisible(false);
        connect(candidateBtn, &QPushButton::clicked, [this, i]() {
            selectCandidate(i);
        });
        m_candidateButtons.append(candidateBtn);
        candidateLayout->addWidget(candidateBtn);
    }
    
    candidateLayout->addStretch();
    
    // 隐藏按钮
    m_hideButton = new KeyboardButton("×", "hide");
    m_hideButton->setFunctionKey(true);
    m_hideButton->setFixedSize(50, 50);
    connect(m_hideButton, &KeyboardButton::keyPressed, this, &TouchKeyboard::hideKeyboard);
    
    // 使用绝对定位将关闭按钮放在右上角
    m_hideButton->setParent(headerWidget);
    m_hideButton->move(headerWidget->width() - 55, 0); // 需要在resize时更新位置
    
    // 标题栏布局：候选词区域铺满整个标题栏
    m_headerLayout = new QHBoxLayout(headerWidget);
    m_headerLayout->setContentsMargins(0, 0, 55, 0); // 右边留出关闭按钮空间
    m_headerLayout->setSpacing(0);
    m_headerLayout->addWidget(m_candidateArea);
    
    // 创建键盘区域
    m_keyboardArea = new QWidget();
    m_keyboardArea->setObjectName("keyboardArea");
    
    // 添加到主布局
    m_mainLayout->addWidget(headerWidget);
    m_mainLayout->addWidget(m_keyboardArea);
    
    // 设置样式
    setStyleSheet(
        "TouchKeyboard {"
        "    background-color: black;"
        "    border: 2px solid #555555;"
        "    border-radius: 8px;"
        "}"
        "#headerWidget {"
        "    background-color: rgb(53, 50, 47);"  // 标题栏背景色设置为rgb(53, 50, 47)
        "    border: none;"
        "    border-radius: 4px;"
        "    margin: 2px 2px 0px 2px;"
        "}"
        "#headerWidget:hover {"
        "    background-color: rgb(65, 62, 59);"  // 悬停时的背景色
        "}"
        "#keyboardArea {"
        "    background-color: black;"
        "    border: 1px solid #444444;"
        "    border-radius: 4px;"
        "    margin: 2px;"
        "}"
    );
    
    // 注意：不在构造函数中调用setMode，因为此时派生类的虚函数表还没有设置好
    // setMode(SimpleMode); // 移除这一行，由派生类负责调用
}

void TouchKeyboard::showKeyboard(QLineEdit *inputField)
{
    // 检查是否刚刚关闭键盘，如果在500ms内则忽略显示请求
    qint64 currentTime = QDateTime::currentMSecsSinceEpoch();
    if (m_lastHideTime > 0 && currentTime - m_lastHideTime < 500) {
        // 即使忽略显示请求，也要确保新的输入框获得焦点
        if (inputField && inputField != m_targetInput) {
            QTimer::singleShot(50, [inputField]() {
                if (inputField) {
                    inputField->setFocus();
                    inputField->setCursorPosition(inputField->text().length());
                }
            });
        }
        return;
    }
    
    // 如果已经显示且目标输入框相同，则不需要重新显示
    if (isVisible() && m_targetInput == inputField) {
        // 确保输入框保持焦点
        if (m_targetInput) {
            QTimer::singleShot(0, [this]() {
                if (m_targetInput) {
                    m_targetInput->setFocus();
                    m_targetInput->setCursorPosition(m_targetInput->text().length());
                }
            });
        }
        return;
    }
    
    // 总是更新目标输入框，即使inputField为nullptr也要处理
    setTargetInput(inputField);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    setFixedSize(keyboardSize);
    
    // 重新创建当前模式的布局以确保尺寸正确
    clearLayout();
    if (m_currentMode == SimpleMode) {
        createSimpleLayout();
    } else {
        createFullLayout();
    }
    
    // 获取定位后的位置
    QPoint targetPos;
    
    // 先定位再显示，确保位置正确
    if (inputField) {
        positionRelativeToInput(inputField);
        targetPos = pos();  // 获取新计算的位置
    } else if (m_targetInput) {
        positionRelativeToInput(m_targetInput);
        targetPos = pos();  // 获取新计算的位置
    } else {
        // 如果没有输入框，居中显示
        QScreen *screen = QApplication::primaryScreen();
        if (screen) {
            QRect screenGeometry = screen->availableGeometry();
            targetPos.setX((screenGeometry.width() - width()) / 2 + screenGeometry.x());
            targetPos.setY((screenGeometry.height() - height()) / 2 + screenGeometry.y());
        }
    }
    
    // 先设置位置再显示，避免闪动
    move(targetPos);
    
    // 显示窗口
    show();
    raise();
    // 不要激活窗口，避免键盘获取焦点
    // activateWindow();
    
    // 确保输入框保持焦点（使用定时器避免焦点冲突）
    if (m_targetInput) {
        QTimer::singleShot(0, [this]() {
            if (m_targetInput) {
                m_targetInput->setFocus();
                m_targetInput->setCursorPosition(m_targetInput->text().length()); // 将光标移到末尾
            }
        });
    }
    
    // 清除隐藏标志
    m_isHiding = false;
    
    // 启动输入监控定时器
    if (m_targetInput) {
        m_lastInputText = m_targetInput->text(); // 初始化上次输入框内容
        updateEnterButtonState(); // 初始化回车键状态
        m_inputMonitorTimer->start(); // 启动定时器
    }
    
    // 创建显示动画
    if (!m_showAnimation) {
        m_showAnimation = new QPropertyAnimation(this, "pos");
        m_showAnimation->setDuration(200);
        m_showAnimation->setEasingCurve(QEasingCurve::OutCubic);
    }
    
    // 停止可能正在运行的动画
    if (m_showAnimation->state() == QAbstractAnimation::Running) {
        m_showAnimation->stop();
    }
    
    // 设置动画起始位置（从当前位置下方50像素开始）
    QPoint startPos = targetPos;
    startPos.setY(startPos.y() + 50);
    
    // 设置动画目标位置为定位后的位置
    m_showAnimation->setStartValue(startPos);
    m_showAnimation->setEndValue(targetPos);
    m_showAnimation->start();
}

void TouchKeyboard::showKeyboard(QTextEdit *textEdit)
{
    // 检查是否刚刚关闭键盘，如果在500ms内则忽略显示请求
    qint64 currentTime = QDateTime::currentMSecsSinceEpoch();
    if (m_lastHideTime > 0 && currentTime - m_lastHideTime < 500) {
        // 即使忽略显示请求，也要确保新的输入框获得焦点
        if (textEdit && textEdit != m_targetTextEdit) {
            QTimer::singleShot(50, [textEdit]() {
                if (textEdit) {
                    textEdit->setFocus();
                    textEdit->moveCursor(QTextCursor::End);
                }
            });
        }
        return;
    }
    
    // 如果已经显示且目标输入框相同，则不需要重新显示
    if (isVisible() && m_targetTextEdit == textEdit) {
        // 确保输入框保持焦点
        if (m_targetTextEdit) {
            QTimer::singleShot(0, [this]() {
                if (m_targetTextEdit) {
                    m_targetTextEdit->setFocus();
                    m_targetTextEdit->moveCursor(QTextCursor::End);
                }
            });
        }
        return;
    }
    
    // 设置目标输入框为QTextEdit
    setTargetInput(textEdit);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    setFixedSize(keyboardSize);
    
    // 重新创建当前模式的布局以确保尺寸正确
    clearLayout();
    if (m_currentMode == SimpleMode) {
        createSimpleLayout();
    } else {
        createFullLayout();
    }
    
    // 获取定位后的位置
    QPoint targetPos;
    
    // 先定位再显示，确保位置正确
    if (textEdit) {
        positionRelativeToInput(textEdit);
        targetPos = pos();  // 获取新计算的位置
    } else if (m_targetTextEdit) {
        positionRelativeToInput(m_targetTextEdit);
        targetPos = pos();  // 获取新计算的位置
    } else {
        // 如果没有输入框，居中显示
        QScreen *screen = QApplication::primaryScreen();
        if (screen) {
            QRect screenGeometry = screen->availableGeometry();
            targetPos.setX((screenGeometry.width() - width()) / 2 + screenGeometry.x());
            targetPos.setY((screenGeometry.height() - height()) / 2 + screenGeometry.y());
        }
    }
    
    // 先设置位置再显示，避免闪动
    move(targetPos);
    
    // 显示窗口
    show();
    raise();
    // 不要激活窗口，避免键盘获取焦点
    // activateWindow();
    
    // 确保输入框保持焦点（使用定时器避免焦点冲突）
    if (m_targetTextEdit) {
        QTimer::singleShot(0, [this]() {
            if (m_targetTextEdit) {
                m_targetTextEdit->setFocus();
                m_targetTextEdit->moveCursor(QTextCursor::End); // 将光标移到末尾
            }
        });
    }
    
    // 清除隐藏标志
    m_isHiding = false;
    
    // 启动输入监控定时器
    if (m_targetTextEdit) {
        m_lastInputText = m_targetTextEdit->toPlainText(); // 初始化上次输入框内容
        updateEnterButtonState(); // 初始化回车键状态
        m_inputMonitorTimer->start(); // 启动定时器
    }
    
    // 创建显示动画
    if (!m_showAnimation) {
        m_showAnimation = new QPropertyAnimation(this, "pos");
        m_showAnimation->setDuration(200);
        m_showAnimation->setEasingCurve(QEasingCurve::OutCubic);
    }
    
    // 停止可能正在运行的动画
    if (m_showAnimation->state() == QAbstractAnimation::Running) {
        m_showAnimation->stop();
    }
    
    // 设置动画起始位置（从当前位置下方50像素开始）
    QPoint startPos = targetPos;
    startPos.setY(startPos.y() + 50);
    
    // 设置动画目标位置为定位后的位置
    m_showAnimation->setStartValue(startPos);
    m_showAnimation->setEndValue(targetPos);
    m_showAnimation->start();
}

void TouchKeyboard::showKeyboard(TextInterface* textInterface)
{
    // 检查是否刚刚关闭键盘，如果在500ms内则忽略显示请求
    qint64 currentTime = QDateTime::currentMSecsSinceEpoch();
    if (m_lastHideTime > 0 && currentTime - m_lastHideTime < 500) {
        // 即使忽略显示请求，也要确保新的输入框获得焦点
        if (textInterface) {
            QTimer::singleShot(50, [textInterface]() {
                if (textInterface) {
                    textInterface->setFocus();
                    textInterface->moveCursorToEnd();
                }
            });
        }
        return;
    }
    
    // 如果已经显示且目标输入框相同，则不需要重新显示
    if (isVisible() && m_targetInputInterface == textInterface) {
        // 确保输入框保持焦点
        if (m_targetInputInterface) {
            QTimer::singleShot(0, [this]() {
                if (m_targetInputInterface) {
                    m_targetInputInterface->setFocus();
                    m_targetInputInterface->moveCursorToEnd();
                }
            });
        }
        return;
    }
    
    // 总是更新目标输入框
    setTargetInput(textInterface);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    setFixedSize(keyboardSize);
    
    // 重新创建当前模式的布局以确保尺寸正确
    clearLayout();
    if (m_currentMode == SimpleMode) {
        createSimpleLayout();
    } else {
        createFullLayout();
    }
    
    // 获取定位后的位置
    QPoint targetPos;
    
    // 先定位再显示，确保位置正确
    if (textInterface) {
        positionRelativeToInput(textInterface);
        targetPos = pos();  // 获取新计算的位置
    } else if (m_targetInputInterface) {
        positionRelativeToInput(m_targetInputInterface);
        targetPos = pos();  // 获取新计算的位置
    } else {
        // 如果没有输入框，居中显示
        QScreen *screen = QApplication::primaryScreen();
        if (screen) {
            QRect screenGeometry = screen->availableGeometry();
            targetPos.setX((screenGeometry.width() - width()) / 2 + screenGeometry.x());
            targetPos.setY((screenGeometry.height() - height()) / 2 + screenGeometry.y());
        }
    }
    
    // 先设置位置再显示，避免闪动
    move(targetPos);
    
    // 显示窗口
    show();
    raise();
    // 不要激活窗口，避免键盘获取焦点
    // activateWindow();
    
    // 确保输入框保持焦点（使用定时器避免焦点冲突）
    if (m_targetInputInterface) {
        QTimer::singleShot(0, [this]() {
            if (m_targetInputInterface) {
                m_targetInputInterface->setFocus();
                m_targetInputInterface->moveCursorToEnd(); // 将光标移到末尾
            }
        });
    }
    
    // 清除隐藏标志
    m_isHiding = false;
    
    // 启动输入监控定时器
    if (m_targetInputInterface) {
        m_lastInputText = m_targetInputInterface->text(); // 初始化上次输入框内容
        updateEnterButtonState(); // 初始化回车键状态
        m_inputMonitorTimer->start(); // 启动定时器
    }
    
    // 创建显示动画
    if (!m_showAnimation) {
        m_showAnimation = new QPropertyAnimation(this, "pos");
        m_showAnimation->setDuration(200);
        m_showAnimation->setEasingCurve(QEasingCurve::OutCubic);
    }
    
    // 停止可能正在运行的动画
    if (m_showAnimation->state() == QAbstractAnimation::Running) {
        m_showAnimation->stop();
    }
    
    // 设置动画起始位置（从当前位置下方50像素开始）
    QPoint startPos = targetPos;
    startPos.setY(startPos.y() + 50);
    
    // 设置动画目标位置为定位后的位置
    m_showAnimation->setStartValue(startPos);
    m_showAnimation->setEndValue(targetPos);
    m_showAnimation->start();
}

void TouchKeyboard::showKeyboard(QPlainTextEdit *plainTextEdit)
{
    // 清除之前的适配器
    if (m_plainTextAdapter) {
        delete m_plainTextAdapter;
        m_plainTextAdapter = nullptr;
    }
    
    // 为QPlainTextEdit创建适配器
    m_plainTextAdapter = new PlainTextEditTextInterface(plainTextEdit);
    showKeyboard(m_plainTextAdapter);
}

void TouchKeyboard::showKeyboard(QComboBox *comboBox)
{
    // 清除之前的适配器
    if (m_comboBoxAdapter) {
        delete m_comboBoxAdapter;
        m_comboBoxAdapter = nullptr;
    }
    
    // 为QComboBox创建适配器
    m_comboBoxAdapter = new ComboBoxTextInterface(comboBox);
    showKeyboard(m_comboBoxAdapter);
}

void TouchKeyboard::hideKeyboard()
{
    // 记录关闭时间
    m_lastHideTime = QDateTime::currentMSecsSinceEpoch();
    
    // 停止输入监控定时器
    if (m_inputMonitorTimer && m_inputMonitorTimer->isActive()) {
        m_inputMonitorTimer->stop();
    }
    
    // 清除目标输入框，防止焦点事件触发自动显示
    m_targetInput = nullptr;
    m_targetTextEdit = nullptr;
    m_targetInputInterface = nullptr;
    
    // 清理适配器但不删除它们，因为它们可能在其他地方被引用
    m_plainTextAdapter = nullptr;
    m_comboBoxAdapter = nullptr;
    
    // 直接隐藏键盘
    hide();
    
    // 发出隐藏信号
    emit keyboardHidden();
}

bool TouchKeyboard::isVisible() const
{
    return QWidget::isVisible();
}


void TouchKeyboard::setMode(KeyboardMode mode)
{
    // 如果模式相同且已经有布局，则直接返回
    if (m_currentMode == mode && m_keyboardArea && m_keyboardArea->layout()) {
        return;
    }
    
    m_currentMode = mode;
    
    // 优化：一次性清除并计算尺寸
    clearLayout();
    
    QSize keyboardSize = calculateKeyboardSize();
    setFixedSize(keyboardSize);
    
    // 重新计算候选词数量（根据新的键盘尺寸）
    calculateMaxCandidateCount();
    
    // 更新关闭按钮位置
    updateHideButtonPosition();
    
    if (!m_keyboardArea) {
        return;
    }
    
    // 设置尺寸策略
    if (mode == SimpleMode) {
        m_keyboardArea->setMinimumSize(0, 0);
        m_keyboardArea->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
        m_keyboardArea->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    } else {
        m_keyboardArea->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    }
    
    // 修复：模式切换时清除中文输入状态
    if (mode == SimpleMode) {
        // 切换到简洁模式时，清除拼音输入状态
        m_currentPinyin.clear();
        m_currentCandidates.clear();
        m_currentPage = 0;
        
        // 确保拼音标签隐藏
        if (m_pinyinLabel) {
            m_pinyinLabel->setVisible(false);
        }
        
        // 确保候选词区域隐藏
        if (m_candidateArea) {
            m_candidateArea->setVisible(false);
        }
    }
    
    // 创建新布局
    if (mode == SimpleMode) {
        createSimpleLayout();
    } else {
        createFullLayout();
    }
    
    // 优化：简化更新操作，只保留必要的
    m_keyboardArea->show();
    updateGeometry();
    
    emit modeChanged(mode);
}

TouchKeyboard::KeyboardMode TouchKeyboard::getMode() const
{
    return m_currentMode;
}

void TouchKeyboard::positionRelativeToInput(QLineEdit *inputField)
{
    if (!inputField) {
        return;
    }
    
    // 获取输入框的全局位置和尺寸
    QPoint inputPos = inputField->mapToGlobal(QPoint(0, 0));
    QSize inputSize = inputField->size();
    QRect inputRect(inputPos, inputSize);
    
    // 获取屏幕尺寸 - 使用更高效的方式
    QScreen *screen = QApplication::screenAt(inputPos);
    if (!screen) {
        screen = QApplication::primaryScreen();
    }
    
    QRect screenGeometry = screen ? screen->availableGeometry() : QRect(0, 0, 1920, 1080);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    
    // 确保键盘尺寸符合最小要求
    if (keyboardSize.width() < minimumWidth()) {
        keyboardSize.setWidth(minimumWidth());
    }
    if (keyboardSize.height() < minimumHeight()) {
        keyboardSize.setHeight(minimumHeight());
    }
    
    // 设置键盘尺寸
    setFixedSize(keyboardSize);
    
    // 计算输入框在屏幕中的相对位置
    int screenCenterY = screenGeometry.center().y();
    int inputCenterY = inputRect.center().y();
    
    // 安全边距：确保键盘与输入框、屏幕边界之间的间距
    const int MARGIN = 15;
    
    QPoint keyboardPos;
    
    // 根据输入框在屏幕中的位置确定键盘的最佳位置
    bool inputInBottomHalf = inputCenterY > screenCenterY;
    
    // 计算键盘在不同位置时的坐标
    // 上方位置
    QPoint topPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                  inputPos.y() - keyboardSize.height() - MARGIN);
    
    // 下方位置
    QPoint bottomPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                     inputPos.y() + inputSize.height() + MARGIN);
    
    // 检查上方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool topValid = (topPos.y() >= screenGeometry.top() + MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                    (topPos.x() >= screenGeometry.left() + MARGIN) &&
                    (topPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= inputRect.y()); // 确保在输入框上方
    
    // 检查下方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool bottomValid = (bottomPos.y() >= screenGeometry.top() + MARGIN) &&
                       (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                       (bottomPos.x() >= screenGeometry.left() + MARGIN) &&
                       (bottomPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                       (bottomPos.y() >= inputRect.y() + inputRect.height()); // 确保在输入框下方
    
    // 选择最佳位置
    if (inputInBottomHalf) {
        // 输入框在下半屏，优先选择上方位置
        if (topValid) {
            keyboardPos = topPos;
        } else if (bottomValid) {
            keyboardPos = bottomPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (topPos.y() >= screenGeometry.top() + MARGIN) {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    } else {
        // 输入框在上半屏，优先选择下方位置
        if (bottomValid) {
            keyboardPos = bottomPos;
        } else if (topValid) {
            keyboardPos = topPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    }
    
    // 最后确保键盘不会遮挡输入框
    if (keyboardPos.y() + keyboardSize.height() > inputRect.y() && 
        keyboardPos.y() < inputRect.y() + inputRect.height()) {
        // 键盘与输入框在垂直方向上有重叠
        if (inputInBottomHalf) {
            // 输入框在下半屏，键盘应该放在上方
            keyboardPos.setY(inputRect.y() - keyboardSize.height() - MARGIN);
        } else {
            // 输入框在上半屏，键盘应该放在下方
            keyboardPos.setY(inputRect.y() + inputRect.height() + MARGIN);
        }
    }
    
    // 确保键盘不会超出屏幕边界
    keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                           keyboardPos.x(), 
                           screenGeometry.right() - keyboardSize.width() - MARGIN));
    keyboardPos.setY(qBound(screenGeometry.top() + MARGIN, 
                           keyboardPos.y(), 
                           screenGeometry.bottom() - keyboardSize.height() - MARGIN));
    
    // 移动键盘到计算出的位置
    move(keyboardPos);
}

void TouchKeyboard::positionRelativeToInput(QTextEdit *textEdit)
{
    if (!textEdit) {
        return;
    }
    
    // 获取输入框的全局位置和尺寸
    QPoint inputPos = textEdit->mapToGlobal(QPoint(0, 0));
    QSize inputSize = textEdit->size();
    QRect inputRect(inputPos, inputSize);
    
    // 获取屏幕尺寸 - 使用更高效的方式
    QScreen *screen = QApplication::screenAt(inputPos);
    if (!screen) {
        screen = QApplication::primaryScreen();
    }
    
    QRect screenGeometry = screen ? screen->availableGeometry() : QRect(0, 0, 1920, 1080);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    
    // 确保键盘尺寸符合最小要求
    if (keyboardSize.width() < minimumWidth()) {
        keyboardSize.setWidth(minimumWidth());
    }
    if (keyboardSize.height() < minimumHeight()) {
        keyboardSize.setHeight(minimumHeight());
    }
    
    // 设置键盘尺寸
    setFixedSize(keyboardSize);
    
    // 计算输入框在屏幕中的相对位置
    int screenCenterY = screenGeometry.center().y();
    int inputCenterY = inputRect.center().y();
    
    // 安全边距：确保键盘与输入框、屏幕边界之间的间距
    const int MARGIN = 15;
    
    QPoint keyboardPos;
    
    // 根据输入框在屏幕中的位置确定键盘的最佳位置
    bool inputInBottomHalf = inputCenterY > screenCenterY;
    
    // 计算键盘在不同位置时的坐标
    // 上方位置
    QPoint topPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                  inputPos.y() - keyboardSize.height() - MARGIN);
    
    // 下方位置
    QPoint bottomPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                     inputPos.y() + inputSize.height() + MARGIN);
    
    // 检查上方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool topValid = (topPos.y() >= screenGeometry.top() + MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                    (topPos.x() >= screenGeometry.left() + MARGIN) &&
                    (topPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= inputRect.y()); // 确保在输入框上方
    
    // 检查下方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool bottomValid = (bottomPos.y() >= screenGeometry.top() + MARGIN) &&
                       (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                       (bottomPos.x() >= screenGeometry.left() + MARGIN) &&
                       (bottomPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                       (bottomPos.y() >= inputRect.y() + inputRect.height()); // 确保在输入框下方
    
    // 选择最佳位置
    if (inputInBottomHalf) {
        // 输入框在下半屏，优先选择上方位置
        if (topValid) {
            keyboardPos = topPos;
        } else if (bottomValid) {
            keyboardPos = bottomPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (topPos.y() >= screenGeometry.top() + MARGIN) {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    } else {
        // 输入框在上半屏，优先选择下方位置
        if (bottomValid) {
            keyboardPos = bottomPos;
        } else if (topValid) {
            keyboardPos = topPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    }
    
    // 最后确保键盘不会遮挡输入框
    if (keyboardPos.y() + keyboardSize.height() > inputRect.y() && 
        keyboardPos.y() < inputRect.y() + inputRect.height()) {
        // 键盘与输入框在垂直方向上有重叠
        if (inputInBottomHalf) {
            // 输入框在下半屏，键盘应该放在上方
            keyboardPos.setY(inputRect.y() - keyboardSize.height() - MARGIN);
        } else {
            // 输入框在上半屏，键盘应该放在下方
            keyboardPos.setY(inputRect.y() + inputRect.height() + MARGIN);
        }
    }
    
    // 确保键盘不会超出屏幕边界
    keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                           keyboardPos.x(), 
                           screenGeometry.right() - keyboardSize.width() - MARGIN));
    keyboardPos.setY(qBound(screenGeometry.top() + MARGIN, 
                           keyboardPos.y(), 
                           screenGeometry.bottom() - keyboardSize.height() - MARGIN));
    
    // 移动键盘到计算出的位置
    move(keyboardPos);
}

void TouchKeyboard::positionRelativeToInput(TextInterface* textInterface)
{
    if (!textInterface) {
        return;
    }
    
    // 获取输入框的全局位置和尺寸
    QPoint inputPos = textInterface->mapToGlobal(QPoint(0, 0));
    QSize inputSize = textInterface->size();
    QRect inputRect(inputPos, inputSize);
    
    // 获取屏幕尺寸 - 使用更高效的方式
    QScreen *screen = QApplication::screenAt(inputPos);
    if (!screen) {
        screen = QApplication::primaryScreen();
    }
    
    QRect screenGeometry = screen ? screen->availableGeometry() : QRect(0, 0, 1920, 1080);
    
    // 重新计算键盘尺寸以确保准确性
    QSize keyboardSize = calculateKeyboardSize();
    
    // 确保键盘尺寸符合最小要求
    if (keyboardSize.width() < minimumWidth()) {
        keyboardSize.setWidth(minimumWidth());
    }
    if (keyboardSize.height() < minimumHeight()) {
        keyboardSize.setHeight(minimumHeight());
    }
    
    // 设置键盘尺寸
    setFixedSize(keyboardSize);
    
    // 计算输入框在屏幕中的相对位置
    int screenCenterY = screenGeometry.center().y();
    int inputCenterY = inputRect.center().y();
    
    // 安全边距：确保键盘与输入框、屏幕边界之间的间距
    const int MARGIN = 15;
    
    QPoint keyboardPos;
    
    // 根据输入框在屏幕中的位置确定键盘的最佳位置
    bool inputInBottomHalf = inputCenterY > screenCenterY;
    
    // 计算键盘在不同位置时的坐标
    // 上方位置
    QPoint topPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                  inputPos.y() - keyboardSize.height() - MARGIN);
    
    // 下方位置
    QPoint bottomPos(inputPos.x() + (inputSize.width() - keyboardSize.width()) / 2,
                     inputPos.y() + inputSize.height() + MARGIN);
    
    // 检查上方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool topValid = (topPos.y() >= screenGeometry.top() + MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                    (topPos.x() >= screenGeometry.left() + MARGIN) &&
                    (topPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                    (topPos.y() + keyboardSize.height() <= inputRect.y()); // 确保在输入框上方
    
    // 检查下方位置是否有效（不超出屏幕边界且不遮挡输入框）
    bool bottomValid = (bottomPos.y() >= screenGeometry.top() + MARGIN) &&
                       (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) &&
                       (bottomPos.x() >= screenGeometry.left() + MARGIN) &&
                       (bottomPos.x() + keyboardSize.width() <= screenGeometry.right() - MARGIN) &&
                       (bottomPos.y() >= inputRect.y() + inputRect.height()); // 确保在输入框下方
    
    // 选择最佳位置
    if (inputInBottomHalf) {
        // 输入框在下半屏，优先选择上方位置
        if (topValid) {
            keyboardPos = topPos;
        } else if (bottomValid) {
            keyboardPos = bottomPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (topPos.y() >= screenGeometry.top() + MARGIN) {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    } else {
        // 输入框在上半屏，优先选择下方位置
        if (bottomValid) {
            keyboardPos = bottomPos;
        } else if (topValid) {
            keyboardPos = topPos;
        } else {
            // 如果上方和下方都无效，选择相对较好的位置
            if (bottomPos.y() + keyboardSize.height() <= screenGeometry.bottom() - MARGIN) {
                keyboardPos = bottomPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            } else {
                keyboardPos = topPos;
                // 调整X坐标确保不超出边界
                keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                                       keyboardPos.x(), 
                                       screenGeometry.right() - keyboardSize.width() - MARGIN));
            }
        }
    }
    
    // 最后确保键盘不会遮挡输入框
    if (keyboardPos.y() + keyboardSize.height() > inputRect.y() && 
        keyboardPos.y() < inputRect.y() + inputRect.height()) {
        // 键盘与输入框在垂直方向上有重叠
        if (inputInBottomHalf) {
            // 输入框在下半屏，键盘应该放在上方
            keyboardPos.setY(inputRect.y() - keyboardSize.height() - MARGIN);
        } else {
            // 输入框在上半屏，键盘应该放在下方
            keyboardPos.setY(inputRect.y() + inputRect.height() + MARGIN);
        }
    }
    
    // 确保键盘不会超出屏幕边界
    keyboardPos.setX(qBound(screenGeometry.left() + MARGIN, 
                           keyboardPos.x(), 
                           screenGeometry.right() - keyboardSize.width() - MARGIN));
    keyboardPos.setY(qBound(screenGeometry.top() + MARGIN, 
                           keyboardPos.y(), 
                           screenGeometry.bottom() - keyboardSize.height() - MARGIN));
    
    // 移动键盘到计算出的位置
    move(keyboardPos);
}

void TouchKeyboard::positionRelativeToInput(QPlainTextEdit *plainTextEdit)
{
    // 清除之前的适配器
    if (m_plainTextAdapter) {
        delete m_plainTextAdapter;
        m_plainTextAdapter = nullptr;
    }
    
    // 为QPlainTextEdit创建适配器
    m_plainTextAdapter = new PlainTextEditTextInterface(plainTextEdit);
    positionRelativeToInput(m_plainTextAdapter);
}

void TouchKeyboard::positionRelativeToInput(QComboBox *comboBox)
{
    // 清除之前的适配器
    if (m_comboBoxAdapter) {
        delete m_comboBoxAdapter;
        m_comboBoxAdapter = nullptr;
    }
    
    // 为QComboBox创建适配器
    m_comboBoxAdapter = new ComboBoxTextInterface(comboBox);
    positionRelativeToInput(m_comboBoxAdapter);
}

void TouchKeyboard::setTargetInput(QLineEdit *input)
{
    // 避免重复设置相同的目标输入框
    if (m_targetInput == input) {
        return;
    }
    
    // 清除之前的QTextEdit目标
    m_targetTextEdit = nullptr;
    // 设置新的QLineEdit目标
    m_targetInput = input;
}

void TouchKeyboard::setTargetInput(QTextEdit *textEdit)
{
    // 避免重复设置相同的目标输入框
    if (m_targetTextEdit == textEdit) {
        return;
    }
    
    // 清除之前的QLineEdit目标
    m_targetInput = nullptr;
    // 设置新的QTextEdit目标
    m_targetTextEdit = textEdit;
}

void TouchKeyboard::setTargetInput(TextInterface* textInterface)
{
    // 避免重复设置相同的目标输入框
    if (m_targetInputInterface == textInterface) {
        return;
    }
    
    // 清除之前的特定类型目标
    m_targetInput = nullptr;
    m_targetTextEdit = nullptr;
    // 清除适配器指针
    m_plainTextAdapter = nullptr;
    m_comboBoxAdapter = nullptr;
    // 设置新的通用接口目标
    m_targetInputInterface = textInterface;
}

void TouchKeyboard::setTargetInput(QPlainTextEdit *plainTextEdit)
{
    // 清除之前的适配器
    if (m_plainTextAdapter) {
        delete m_plainTextAdapter;
    }
    
    // 为QPlainTextEdit创建适配器
    m_plainTextAdapter = new PlainTextEditTextInterface(plainTextEdit);
    setTargetInput(m_plainTextAdapter);
}

void TouchKeyboard::setTargetInput(QComboBox *comboBox)
{
    // 清除之前的适配器
    if (m_comboBoxAdapter) {
        delete m_comboBoxAdapter;
    }
    
    // 为QComboBox创建适配器
    m_comboBoxAdapter = new ComboBoxTextInterface(comboBox);
    setTargetInput(m_comboBoxAdapter);
}


QLineEdit* TouchKeyboard::getTargetInput() const
{
    return m_targetInput;
}

QTextEdit* TouchKeyboard::getTargetTextEdit() const
{
    return m_targetTextEdit;
}

TextInterface* TouchKeyboard::getTargetInputInterface() const
{
    return m_targetInputInterface;
}

void TouchKeyboard::mousePressEvent(QMouseEvent *event)
{
    // 只有在标题栏区域点击才允许拖拽

    if (event->button() == Qt::LeftButton) {
        // 获取鼠标点击位置
        QPoint clickPos = event->pos();
        
        // 检查是否在标题栏区域内（整个标题栏区域，高度为50像素）
        if (clickPos.y() <= 50) {
            m_isDragging = true;
            m_dragStartPosition = event->globalPos();
            m_windowStartPosition = pos();
            setCursor(Qt::ClosedHandCursor);
        }
    }
    QWidget::mousePressEvent(event);
}

void TouchKeyboard::mouseMoveEvent(QMouseEvent *event)
{
    if (m_isDragging && (event->buttons() & Qt::LeftButton)) {
        QPoint delta = event->globalPos() - m_dragStartPosition;
        move(m_windowStartPosition + delta);
    }
    QWidget::mouseMoveEvent(event);
}

void TouchKeyboard::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        m_isDragging = false;
        setCursor(Qt::ArrowCursor);
    }
    QWidget::mouseReleaseEvent(event);
}

// 添加触摸事件处理函数，确保在触摸屏上也能正常工作
void TouchKeyboard::touchEvent(QTouchEvent *event)
{
    // 处理触摸事件，使拖拽功能在触摸屏上也能正常工作
    if (event->type() == QEvent::TouchBegin) {
        // 触摸开始事件
        QList<QTouchEvent::TouchPoint> touchPoints = event->touchPoints();
        if (!touchPoints.isEmpty()) {
            QTouchEvent::TouchPoint touchPoint = touchPoints.first();
            QPoint touchPos = touchPoint.pos().toPoint();
            
            // 检查是否在标题栏区域内（整个标题栏区域，高度为50像素）
            if (touchPos.y() <= 50) {
                m_isDragging = true;
                m_dragStartPosition = touchPoint.screenPos().toPoint();
                m_windowStartPosition = pos();
                setCursor(Qt::ClosedHandCursor);
            }
        }
    } else if (event->type() == QEvent::TouchUpdate) {
        // 触摸移动事件
        if (m_isDragging) {
            QList<QTouchEvent::TouchPoint> touchPoints = event->touchPoints();
            if (!touchPoints.isEmpty()) {
                QTouchEvent::TouchPoint touchPoint = touchPoints.first();
                QPoint delta = touchPoint.screenPos().toPoint() - m_dragStartPosition;
                move(m_windowStartPosition + delta);
            }
        }
    } else if (event->type() == QEvent::TouchEnd) {
        // 触摸结束事件
        m_isDragging = false;
        setCursor(Qt::ArrowCursor);
    }
    
    event->accept();
}

void TouchKeyboard::paintEvent(QPaintEvent *event)
{
    QWidget::paintEvent(event);
}

void TouchKeyboard::showEvent(QShowEvent *event)
{
    QWidget::showEvent(event);
    
    // 确保关闭按钮位置正确
    updateHideButtonPosition();
}

void TouchKeyboard::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);
    
    // 更新关闭按钮位置
    updateHideButtonPosition();
    
    // 重新计算候选词数量
    calculateMaxCandidateCount();
    
    // 更新拖拽提示标签位置，使其居中
    updateDragHintLabelPosition();
}

void TouchKeyboard::updateDragHintLabelPosition()
{
    // 查找拖拽提示标签并更新其位置
    QLabel *dragHintLabel = findChild<QLabel*>("dragHintLabel");
    QWidget *headerWidget = findChild<QWidget*>("headerWidget");
    
    if (dragHintLabel && headerWidget) {
        // 获取标签的推荐尺寸
        QFontMetrics fm(dragHintLabel->font());
        int textWidth = fm.horizontalAdvance("✥✥ 拖拽移动 ✥✥") + 20; // 加上padding
        int labelWidth = qMax(textWidth, 140); // 最小宽度140px
        int labelHeight = 30;
        
        // 计算居中位置
        int x = (headerWidget->width() - labelWidth) / 2;
        int y = 10;
        
        // 设置标签位置和尺寸
        dragHintLabel->setGeometry(x, y, labelWidth, labelHeight);
    }
}

void TouchKeyboard::onKeyPressed(const QString &key)
{
    // 处理特殊功能键
    if (key == "mode") {
        // 模式切换功能
        onModeToggle();
        return;
    }
    
    if (key == "language") {
        // 启用中英文切换功能
        onLanguageToggle();
        return;
    }
    
    if (key == "shift") {
        // 大小写切换功能
        onShiftToggle();
        return;
    }
    
    // 处理通用文本接口输入
    if (m_targetInputInterface) {
        if (key == "backspace") {
            // 在中文输入模式下，先删除拼音，再删除输入框内容
            if (m_isChineseMode && !m_currentPinyin.isEmpty() && m_currentMode != SimpleMode) {
                // 删除一个拼音字母
                m_currentPinyin.chop(1);
                // 更新候选词
                QString candidates = getPinyinCandidates(m_currentPinyin);
                if (!candidates.isEmpty()) {
                    m_currentCandidates = candidates.split(",");
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 更新拼音标签显示
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);
                    }
                } else {
                    // 没有候选词，清空候选词但保持拼音显示
                    m_currentCandidates.clear();
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 仍然显示拼音标签，即使没有候选词
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        // 修复：拼音全删除时应该隐藏拼音标签，否则显示当前拼音
                        m_pinyinLabel->setVisible(!m_currentPinyin.isEmpty());
                    }
                }
                // 更新回车键状态
                updateEnterButtonState();
                return;
            } else {
                // 普通退格操作
                m_targetInputInterface->backspace();
            }
        } else if (key == "clear" || key == "clear_all") {
            // 清除输入框内容
            m_targetInputInterface->clear();
            // 如果在中文模式下，也要清除拼音缓冲区
            if (m_isChineseMode) {
                m_currentPinyin.clear();
                m_currentCandidates.clear();
                m_currentPage = 0;
                updateCandidateDisplay();
                // 隐藏拼音标签（拼音已清空）
                if (m_pinyinLabel) {
                    m_pinyinLabel->setVisible(false);
                }
            }
        } else if (key == "enter") {
            // 回车键直接关闭键盘
            hideKeyboard();
            
            // 确保输入框失去焦点后再恢复焦点，避免焦点循环
            if (m_targetInputInterface) {
                QTimer::singleShot(100, [this]() {
                    if (m_targetInputInterface) {
                        // 对于通用接口，我们不直接操作焦点，而是通过适配器处理
                        QTimer::singleShot(50, [this]() {
                            if (m_targetInputInterface) {
                                m_targetInputInterface->setFocus();
                            }
                        });
                    }
                });
            }
            return;
        } else if (key == "<" && m_isChineseMode && m_currentMode != SimpleMode) {
            // 中文输入模式下的上一页（只在中文模式下支持）
            previousPage();
            return;
        } else if (key == ">" && m_isChineseMode && m_currentMode != SimpleMode) {
            // 中文输入模式下的下一页（只在中文模式下支持）
            nextPage();
            return;
        } else {
            // 处理字符输入
            if (m_isChineseMode && key.length() == 1 && key.at(0).isLetter() && m_currentMode != SimpleMode) {
                // 中文输入模式下的拼音输入（只在中文模式下支持中文输入）
                m_currentPinyin += key.toLower();
                QString candidates = getPinyinCandidates(m_currentPinyin);
                if (!candidates.isEmpty()) {
                    m_currentCandidates = candidates.split(",");
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    
                    // 显示当前拼音
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);
                    }
                } else {
                    // 没有候选词，清空候选词但保持拼音显示
                    m_currentCandidates.clear();
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 修复：即使没有候选词也应该显示当前输入的拼音
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);  // 始终显示拼音标签，因为我们有拼音输入
                    }
                }
                // 更新回车键状态
                updateEnterButtonState();
                return;
            } else {
                // 处理普通字符输入（英文模式或其他非拼音输入）
                QString actualKey = key;
                if (m_isCapitalized && key.length() == 1 && key.at(0).isLetter()) {
                    actualKey = key.toUpper();
                }
                // 插入文本
                m_targetInputInterface->insertText(actualKey);
            }
        }
        
        // 更新回车键状态（在处理完输入后）
        updateEnterButtonState();
    }
    // 处理QLineEdit输入（保持向后兼容）
    else if (m_targetInput) {
        if (key == "backspace") {
            // 在中文输入模式下，先删除拼音，再删除输入框内容
            if (m_isChineseMode && !m_currentPinyin.isEmpty() && m_currentMode != SimpleMode) {
                // 删除一个拼音字母
                m_currentPinyin.chop(1);
                // 更新候选词
                QString candidates = getPinyinCandidates(m_currentPinyin);
                if (!candidates.isEmpty()) {
                    m_currentCandidates = candidates.split(",");
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 更新拼音标签显示
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);
                    }
                } else {
                    // 没有候选词，清空候选词但保持拼音显示
                    m_currentCandidates.clear();
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 仍然显示拼音标签，即使没有候选词
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        // 修复：拼音全删除时应该隐藏拼音标签，否则显示当前拼音
                        m_pinyinLabel->setVisible(!m_currentPinyin.isEmpty());
                    }
                }
                // 更新回车键状态
                updateEnterButtonState();
                return;
            } else {
                // 普通退格操作
                m_targetInput->backspace();
            }
        } else if (key == "clear" || key == "clear_all") {
            // 清除输入框内容
            m_targetInput->clear();
            // 如果在中文模式下，也要清除拼音缓冲区
            if (m_isChineseMode) {
                m_currentPinyin.clear();
                m_currentCandidates.clear();
                m_currentPage = 0;
                updateCandidateDisplay();
                // 隐藏拼音标签（拼音已清空）
                if (m_pinyinLabel) {
                    m_pinyinLabel->setVisible(false);
                }
            }
        } else if (key == "enter") {
            // 回车键直接关闭键盘
            hideKeyboard();
            
            // 确保输入框失去焦点后再恢复焦点，避免焦点循环
            if (m_targetInput) {
                QTimer::singleShot(100, [this]() {
                    if (m_targetInput) {
                        m_targetInput->clearFocus();
                        QTimer::singleShot(50, [this]() {
                            if (m_targetInput) {
                                m_targetInput->setFocus();
                            }
                        });
                    }
                });
            }
            return;
        } else if (key == "<" && m_isChineseMode && m_currentMode != SimpleMode) {
            // 中文输入模式下的上一页（只在中文模式下支持）
            previousPage();
            return;
        } else if (key == ">" && m_isChineseMode && m_currentMode != SimpleMode) {
            // 中文输入模式下的下一页（只在中文模式下支持）
            nextPage();
            return;
        } else {
            // 处理字符输入
            if (m_isChineseMode && key.length() == 1 && key.at(0).isLetter() && m_currentMode != SimpleMode) {
                // 中文输入模式下的拼音输入（只在中文模式下支持中文输入）
                m_currentPinyin += key.toLower();
                QString candidates = getPinyinCandidates(m_currentPinyin);
                if (!candidates.isEmpty()) {
                    m_currentCandidates = candidates.split(",");
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    
                    // 显示当前拼音
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);
                    }
                } else {
                    // 没有候选词，清空候选词但保持拼音显示
                    m_currentCandidates.clear();
                    m_currentPage = 0;
                    updateCandidateDisplay();
                    // 修复：即使没有候选词也应该显示当前输入的拼音
                    if (m_pinyinLabel) {
                        m_pinyinLabel->setText(m_currentPinyin);
                        m_pinyinLabel->setVisible(true);  // 始终显示拼音标签，因为我们有拼音输入
                    }
                }
                // 更新回车键状态
                updateEnterButtonState();
                return;
            } else {
                // 处理普通字符输入（英文模式或其他非拼音输入）
                QString actualKey = key;
                if (m_isCapitalized && key.length() == 1 && key.at(0).isLetter()) {
                    actualKey = key.toUpper();
                }
                // 插入文本到QLineEdit
                m_targetInput->insert(actualKey);
            }
        }
        
        // 更新回车键状态（在处理完输入后）
        updateEnterButtonState();
    }
}

void TouchKeyboard::onModeToggle()
{
    // 切换模式
    if (m_currentMode == SimpleMode) {
        setMode(FullMode);
    } else {
        setMode(SimpleMode);
    }
}

void TouchKeyboard::onLanguageToggle()
{
    // 保存当前的输入目标，以便在切换后能正确处理输入
    QLineEdit* currentInput = m_targetInput;
    QTextEdit* currentTextEdit = m_targetTextEdit;
    TextInterface* currentInterface = m_targetInputInterface;
    
    // 启用中英文输入切换功能
    // 切换中英文输入模式
    m_isChineseMode = !m_isChineseMode;
    
    // 更新语言按钮文字
    updateLanguageButtonText();
    
    if (m_isChineseMode) {
        // 切换到中文模式
        // 候选词区域应该根据是否有候选词来决定是否显示，但在简洁模式下不显示
        if (m_candidateArea) {
            m_candidateArea->setVisible(!m_currentCandidates.isEmpty() && (m_currentMode != SimpleMode));
        }
        if (m_pinyinLabel) {
            m_pinyinLabel->setVisible(!m_currentPinyin.isEmpty() && (m_currentMode != SimpleMode));
        }
    } else {
        // 切换到英文模式
        if (m_candidateArea) {
            m_candidateArea->setVisible(false);
        }
        if (m_pinyinLabel) {
            m_pinyinLabel->setVisible(false);
        }
        
        // 清空拼音缓冲区
        m_currentPinyin.clear();
        m_currentCandidates.clear();
        m_currentPage = 0;
        
        // 更新候选词显示
        updateCandidateDisplay();
    }
    
    // 确保界面更新
    if (m_candidateArea) {
        m_candidateArea->update();
    }
    
    // 确保输入框仍然有焦点
    if (currentInterface) {
        QTimer::singleShot(0, [currentInterface]() {
            currentInterface->setFocus();
        });
    } else if (currentInput) {
        QTimer::singleShot(0, [currentInput]() {
            currentInput->setFocus();
            currentInput->setCursorPosition(currentInput->text().length());
        });
    } else if (currentTextEdit) {
        QTimer::singleShot(0, [currentTextEdit]() {
            currentTextEdit->setFocus();
            currentTextEdit->moveCursor(QTextCursor::End);
        });
    }
}

void TouchKeyboard::onShiftToggle()
{
    // 切换大小写
    m_isCapitalized = !m_isCapitalized;
    
    // 重新创建当前模式的布局以更新字母显示
    if (m_currentMode == FullMode) {
        clearLayout();
        createFullLayout();
    }
}

void TouchKeyboard::clearLayout()
{
    if (!m_keyboardArea) {
        return;
    }
    
    // 优化：不直接删除布局和控件，而是隐藏它们，让SimpleKeyboard管理它们的生命周期
    QLayout *layout = m_keyboardArea->layout();
    if (layout) {
        QLayoutItem *item;
        while ((item = layout->takeAt(0)) != nullptr) {
            if (item->widget()) {
                // 隐藏按钮而不是删除，让SimpleKeyboard管理它们的生命周期
                item->widget()->hide();
            }
            delete item;
        }
        // 不删除布局，而是重用它
        // delete layout;
    }
    
    // 隐藏键盘区域的所有子控件而不是删除它们
    QList<QWidget*> widgets = m_keyboardArea->findChildren<QWidget*>(QString(), Qt::FindDirectChildrenOnly);
    for (QWidget *widget : widgets) {
        if (widget != m_candidateArea) { // 不隐藏候选词区域
            widget->hide();
        }
    }
}

QSize TouchKeyboard::getScreenSize() const
{
    QScreen *screen = QGuiApplication::primaryScreen();
    if (screen) {
        return screen->availableSize();
    }
    return QSize(1920, 1080); // 默认尺寸
}

QSize TouchKeyboard::calculateKeyboardSize() const
{
    // 获取当前屏幕信息
    QScreen *screen = QGuiApplication::primaryScreen();
    QRect screenGeometry;
    
    if (screen) {
        screenGeometry = screen->availableGeometry();
    } else {
        // 默认屏幕尺寸
        screenGeometry = QRect(0, 0, 1920, 1080);
    }
    
    QSize screenSize = screenGeometry.size();
    
    // 根据当前模式计算键盘尺寸
    int width, height;
    if (m_currentMode == SimpleMode) {
        // 简洁模式：宽度为屏幕的三分之一
        width = screenSize.width() / 3;
        // 考虑到按钮尺寸放大一倍，需要适当增加高度
        height = static_cast<int>(screenSize.height() * 0.45); // 从40%增加到45%
    } else {
        // 全键盘模式：宽度为屏幕的80%
        width = static_cast<int>(screenSize.width() * 0.6);
        height = static_cast<int>(screenSize.height() * 0.45); // 保持40%高度
    }
    
    // 确保最小尺寸
    width = qMax(width, 400);
    height = qMax(height, 200);
    
    return QSize(width, height);
}

int TouchKeyboard::calculateButtonSize() const
{
    QSize keyboardSize = calculateKeyboardSize();
    
    // 根据键盘尺寸计算按钮大小
    int buttonSize;
    if (m_currentMode == SimpleMode) {
        // 简洁模式：4行4列布局
        // 考虑边距和间距，确保按钮为正方形且宽高一致
        int availableWidth = keyboardSize.width() - 40;  // 减去左右边距
        int availableHeight = keyboardSize.height() - 100; // 减去上下边距和标题栏高度
        
        // 计算基于宽度和高度的按钮尺寸
        int buttonSizeFromWidth = (availableWidth - 3 * 10) / 4;  // 4列，3个间距
        int buttonSizeFromHeight = (availableHeight - 3 * 10) / 4; // 4行，3个间距
        
        // 取较小值确保按钮能完整显示
        buttonSize = qMin(buttonSizeFromWidth, buttonSizeFromHeight);
    } else {
        // 全键盘模式：假设4行4列
        buttonSize = (keyboardSize.width() - 40) / 4; // 减去边距和间距，4列
    }
    
    // 确保最小按钮尺寸
    return qMax(buttonSize, 40);
}

int TouchKeyboard::calculateSpacing() const
{
    // 计算按钮间距，约为按钮尺寸的1/10
    int buttonSize = calculateButtonSize();
    return qMax(buttonSize / 10, 2);
}

QString TouchKeyboard::evaluateExpression(const QString &expression)
{
    try {
        double result = evaluateSimpleExpression(expression);
        return QString::number(result, 'g', 10);
    } catch (const std::exception &e) {
        return QString("Error: %1").arg(e.what());
    } catch (...) {
        return QString("Error: Invalid expression");
    }
}

double TouchKeyboard::evaluateSimpleExpression(const QString &expr)
{
    // 简单的数学表达式计算器
    // 支持 +, -, *, /, (, )
    // 注意：这是一个简化的实现，实际项目中应该使用更健壮的表达式解析器
    
    QString expression = expr;
    expression.remove(" "); // 移除空格
    
    // 使用 Qt 的表达式计算器（如果可用）或自定义实现
    // 这里使用一个简单的实现
    
    QRegularExpression numberRegex("(-?\\d+(?:\\.\\d+)?)");
    QRegularExpression operatorRegex("([+\\-*/])");
    
    // 简单实现：只处理两个数的运算
    QRegularExpression fullRegex("^(-?\\d+(?:\\.\\d+)?)\\s*([+\\-*/])\\s*(-?\\d+(?:\\.\\d+)?)$");
    QRegularExpressionMatch match = fullRegex.match(expression);
    
    if (match.hasMatch()) {
        double num1 = match.captured(1).toDouble();
        QString op = match.captured(2);
        double num2 = match.captured(3).toDouble();
        
        if (op == "+") {
            return num1 + num2;
        } else if (op == "-") {
            return num1 - num2;
        } else if (op == "*") {
            return num1 * num2;
        } else if (op == "/") {
            if (num2 != 0) {
                return num1 / num2;
            } else {
                throw std::runtime_error("Division by zero");
            }
        }
    }
    
    throw std::runtime_error("Invalid expression format");
}

void TouchKeyboard::initChineseCandidates()
{
    // 初始化中文拼音候选词映射表
    // 从谷歌拼音输入法资源包加载词库
    this->pinyinMap.clear();
    
    // 定义谷歌拼音词典文件路径
    QString dictPath = ":/pinyin_dict/google_pinyin.dict";  // 使用Qt资源系统
    QString userDictPath = QDir::homePath() + "/.touchkeyboard/google_pinyin.dict";  // 用户目录下的词典
    
    // 尝试从资源文件加载
    if (loadPinyinDictFromFile(dictPath)) {
        return;
    }
    
    // 如果资源文件不存在，尝试从用户目录加载
    if (loadPinyinDictFromFile(userDictPath)) {
        return;
    }
    
    // 如果文件都不存在，加载基础拼音映射（兼容模式）
    loadDefaultPinyinMap();
}

bool TouchKeyboard::loadPinyinDictFromFile(const QString &filePath)
{
    QFile dictFile(filePath);
    if (!dictFile.exists() || !dictFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
        return false;
    }
    
    QTextStream in(&dictFile);
    in.setCodec("UTF-8");
    
    QString line;
    while (!in.atEnd()) {
        line = in.readLine().trimmed();
        if (line.isEmpty() || line.startsWith("#")) {
            continue;  // 跳过空行和注释行
        }
        
        // 解析格式: pinyin,word1,word2,word3...
        QStringList parts = line.split(",");
        if (parts.size() >= 2) {
            QString pinyin = parts[0].trimmed();
            QStringList words;
            for (int i = 1; i < parts.size(); ++i) {
                QString word = parts[i].trimmed();
                if (!word.isEmpty()) {
                    words.append(word);
                }
            }
            
            if (!pinyin.isEmpty() && !words.isEmpty()) {
                pinyinMap[pinyin] = words.join(",");
            }
        }
    }
    
    dictFile.close();
    return !pinyinMap.isEmpty();
}

void TouchKeyboard::loadDefaultPinyinMap()
{
    // 基础拼音映射（兼容模式）
    this->pinyinMap["a"] = "啊,阿,呵,吖,锕";
    pinyinMap["ai"] = "爱,艾,挨,哎,唉,哀,皑,癌,蔼,矮,艾,隘,霭";
    pinyinMap["an"] = "安,按,案,暗,岸,俺,鞍,氨,庵,谙,鹌,埯,黯";
    pinyinMap["ang"] = "昂,盎,肮";
    pinyinMap["ao"] = "奥,傲,澳,懊,凹,敖,翱,袄,坳,遨,嗷,廒,獒,遨";
    pinyinMap["ba"] = "把,爸,八,吧,罢,拔,霸,坝,芭,扒,耙,疤,捌,笆,靶,鲅";
    pinyinMap["bai"] = "白,百,摆,败,拜,柏,佰,掰,稗,捭";
    pinyinMap["ban"] = "办,板,半,般,班,搬,版,拌,伴,瓣,颁,斑,坂,阪,钣";
    pinyinMap["bang"] = "帮,棒,绑,榜,膀,蚌,傍,谤,磅,镑,浜,蒡";
    pinyinMap["bao"] = "保,报,包,暴,宝,抱,报,胞,炮,饱,堡,苞,褒,雹,煲,鸨";
    pinyinMap["bei"] = "被,北,备,背,杯,倍,贝,碑,悲,卑,辈,狈,焙,蓓,悖,惫,碚";
    pinyinMap["ben"] = "本,奔,笨,苯,畚,坌,锛";
    pinyinMap["beng"] = "崩,绷,甭,泵,蹦,迸,甏,嘣";
    pinyinMap["bi"] = "比,笔,必,毕,币,闭,逼,彼,避,鼻,臂,碧,蔽,弊,壁,璧,蓖,痹,陛,匕,鄙,哔,荸,裨,跸,濞,弼,妣,婢,嬖,襞";
    pinyinMap["bian"] = "变,边,便,编,遍,辩,辨,辫,扁,贬,匾,汴,煸,砭,碥,蝙";
    pinyinMap["biao"] = "表,标,彪,膘,飙,镖,飙,婊,裱,鳔";
    pinyinMap["bie"] = "别,憋,鳖,瘪,蹩";
    pinyinMap["bin"] = "宾,滨,彬,斌,濒,槟,殡,膑,镔";
    pinyinMap["bing"] = "并,病,兵,冰,丙,柄,饼,炳,秉,禀,槟,摒,膑,镖";
    pinyinMap["bo"] = "波,播,伯,博,勃,博,玻,剥,泊,卜,勃,驳,帛,舶,渤,脖,膊,簸,铂,箔,礴,跛,钹,饽,檗,擘,礴";
    pinyinMap["bu"] = "不,布,部,步,补,捕,布,卜,哺,堡,埔,簿,埠,怖,钚,卟";
    
    // 更多拼音映射...
    // 实际项目中应该加载完整的拼音词典
}

void TouchKeyboard::updateCandidateDisplay()
{
    if (!m_candidateArea) {
        return;
    }
    
    // 优化：只在候选词发生变化时才更新显示
    static QStringList lastCandidates;
    static int lastPage = -1;
    static QString lastPinyin;
    
    if (lastCandidates == m_currentCandidates && lastPage == m_currentPage && lastPinyin == m_currentPinyin) {
        return; // 没有变化，不需要更新
    }
    
    lastCandidates = m_currentCandidates;
    lastPage = m_currentPage;
    lastPinyin = m_currentPinyin;
    
    // 隐藏所有候选词按钮
    for (QPushButton *btn : m_candidateButtons) {
        btn->setVisible(false);
    }
    
    // 显示当前页的候选词
    int startIndex = m_currentPage * m_maxCandidateCount;
    for (int i = 0; i < m_maxCandidateCount && (startIndex + i) < m_currentCandidates.size(); ++i) {
        if (i < m_candidateButtons.size()) {
            QPushButton *btn = m_candidateButtons[i];
            btn->setText(m_currentCandidates[startIndex + i]);
            btn->setVisible(true);
        }
    }
    
    // 更新候选词区域显示
    // 修复：在简洁模式下不应该显示候选词区域
    bool shouldShow = !m_currentPinyin.isEmpty() && (m_currentMode != SimpleMode);
    if (m_candidateArea->isVisible() != shouldShow) {
        m_candidateArea->setVisible(shouldShow);
    }
    
    // 确保拼音标签根据拼音内容显示或隐藏
    if (m_pinyinLabel) {
        bool pinyinVisible = !m_currentPinyin.isEmpty() && (m_currentMode != SimpleMode);
        if (m_pinyinLabel->isVisible() != pinyinVisible) {
            m_pinyinLabel->setVisible(pinyinVisible);
        }
        // 确保拼音标签显示正确的拼音内容
        if (pinyinVisible) {
            m_pinyinLabel->setText(m_currentPinyin);
        }
    }
}

void TouchKeyboard::selectCandidate(int index)
{
    if (index < 0 || index >= m_currentCandidates.size()) {
        return;
    }
    
    QString selectedWord = m_currentCandidates[index];
    if (m_targetInputInterface) {
        // 插入选中的候选词
        m_targetInputInterface->insertText(selectedWord);
    } else if (m_targetInput) {
        // 插入选中的候选词
        m_targetInput->insert(selectedWord);
    }
    
    // 清空拼音和候选词
    m_currentPinyin.clear();
    m_currentCandidates.clear();
    m_currentPage = 0;
    
    // 优化：只在候选词区域可见时才更新显示
    if (m_candidateArea && m_candidateArea->isVisible()) {
        updateCandidateDisplay();
    }
    
    // 隐藏拼音标签
    if (m_pinyinLabel) {
        m_pinyinLabel->setVisible(false);
    }
}

void TouchKeyboard::nextPage()
{
    int totalPages = (m_currentCandidates.size() + m_maxCandidateCount - 1) / m_maxCandidateCount;
    if (m_currentPage < totalPages - 1) {
        m_currentPage++;
        updateCandidateDisplay();
    }
}

void TouchKeyboard::previousPage()
{
    if (m_currentPage > 0) {
        m_currentPage--;
        updateCandidateDisplay();
    }
}

QString TouchKeyboard::getPinyinCandidates(const QString &pinyin)
{
    // 初始化拼音映射表（如果尚未初始化）
    if (this->pinyinMap.isEmpty()) {
        initChineseCandidates();
    }
    
    // 如果拼音为空，直接返回空字符串
    if (pinyin.isEmpty()) {
        return QString();
    }
    
    // 直接匹配
    if (this->pinyinMap.contains(pinyin)) {
        return this->pinyinMap[pinyin];
    }
    
    // 使用缓存优化：如果之前已经搜索过这个拼音，直接返回缓存结果
    static QMap<QString, QString> searchCache;
    if (searchCache.contains(pinyin)) {
        return searchCache[pinyin];
    }
    
    // 模糊匹配：查找以输入拼音开头的所有候选词
    QStringList allMatches;
    QString searchPinyin = pinyin.toLower();
    
    // 1. 精确匹配
    auto exactMatch = this->pinyinMap.find(searchPinyin);
    if (exactMatch != this->pinyinMap.end()) {
        searchCache[pinyin] = exactMatch.value();
        return exactMatch.value();
    }
    
    // 2. 前缀匹配 - 优化：只遍历一次，同时收集所有匹配项
    QMap<int, QStringList> lengthGroups;
    for (auto it = this->pinyinMap.constBegin(); it != this->pinyinMap.constEnd(); ++it) {
        if (it.key().startsWith(searchPinyin) && it.key() != searchPinyin) {
            int length = it.key().length();
            if (!lengthGroups.contains(length)) {
                lengthGroups[length] = QStringList();
            }
            QStringList words = it.value().split(",");
            // 只取前几个最常用的候选词，避免过多候选词
            int wordsToAdd = qMin(3, words.size());
            for (int i = 0; i < wordsToAdd; ++i) {
                const QString& word = words[i];
                if (!lengthGroups[length].contains(word)) {
                    lengthGroups[length].append(word);
                    if (!allMatches.contains(word)) {
                        allMatches.append(word);
                    }
                }
            }
        }
    }
    
    // 3. 按拼音长度排序，优先显示较短的拼音对应的候选词
    QList<int> lengths = lengthGroups.keys();
    std::sort(lengths.begin(), lengths.end());
    
    QStringList candidates;
    for (int length : lengths) {
        candidates.append(lengthGroups[length]);
        // 限制候选词总数，避免过多
        if (candidates.size() >= 15) {
            candidates = candidates.mid(0, 15);
            break;
        }
    }
    
    // 缓存结果
    QString result = candidates.join(",");
    // 只缓存非空结果，避免缓存空字符串导致的问题
    if (!result.isEmpty()) {
        searchCache[pinyin] = result;
    }
    
    // 限制缓存大小，避免内存占用过大
    if (searchCache.size() > 100) {
        // 移除最早的几个缓存项
        auto it = searchCache.begin();
        for (int i = 0; i < 10 && it != searchCache.end(); ++i) {
            it = searchCache.erase(it);
        }
    }
    
    return result;
}

void TouchKeyboard::calculateMaxCandidateCount()
{
    // 根据标题栏宽度计算可以放置的最大候选词数量
    QSize keyboardSize = calculateKeyboardSize();
    int availableWidth = keyboardSize.width() - 80; // 留出拼音区域和关闭按钮空间
    int buttonMinWidth = 40; // 每个候选词按钮最小宽度
    int spacing = 3; // 按钮间距
    
    // 计算最大可放置的按钮数量
    int maxCount = (availableWidth + spacing) / (buttonMinWidth + spacing);
    m_maxCandidateCount = qMin(qMax(maxCount, 9), 9); // 限制在5个（根据需求修改）
}

void TouchKeyboard::updateHideButtonPosition()
{
    if (m_hideButton && m_hideButton->parent()) {
        QWidget *parent = qobject_cast<QWidget*>(m_hideButton->parent());
        if (parent) {
            // 确保关闭按钮在标题栏右上角
            m_hideButton->move(parent->width() - 55, 0);
            m_hideButton->raise(); // 确保关闭按钮在最上层
        }
    }
}

void TouchKeyboard::updateLanguageButtonText()
{
    if (m_languageButton) {
        // 根据当前语言模式显示不同的文字
        QString displayText = m_isChineseMode ? "中" : "En";
        m_languageButton->setText(displayText);
    }
}

void TouchKeyboard::updateEnterButtonState()
{
    // 更新回车键状态
    if (m_enterButton) {
        // 检查输入框是否有内容
        bool hasContent = false;
        if (m_targetInputInterface) {
            hasContent = !m_targetInputInterface->text().isEmpty();
        } else if (m_targetInput) {
            hasContent = !m_targetInput->text().isEmpty();
        } else if (m_targetTextEdit) {
            hasContent = !m_targetTextEdit->toPlainText().isEmpty();
        }
        
        if (hasContent) {
            // 有内容时，高亮显示并显示"确认"字样
            m_enterButton->setText("确认");
            m_enterButton->setStyleSheet(
                "KeyboardButton {"
                "    background-color: #4CAF50;"  // 绿色背景表示可确认
                "    color: white;"
                "    border: 1px solid #45a049;"
                "    border-radius: 4px;"
                "    font-weight: bold;"
                "} "
                "KeyboardButton:hover {"
                "    background-color: #45a049;"
                "} "
                "KeyboardButton:pressed {"
                "    background-color: #3d8b40;"
                "}"
            );
        } else {
            // 无内容时，恢复默认状态和回车图标
            m_enterButton->setText("↵");
            // 恢复为普通功能键的样式，而不是清除所有样式
            m_enterButton->setStyleSheet(
                "KeyboardButton {"
                "    border: 1px solid #666666;"
                "    border-radius: 6px;"
                "    background-color: rgb(53, 50, 47);"
                "    color: #87CEEB;"
                "    font-weight: bold;"
                "    padding: 2px;"
                "    min-width: 30px;"
                "    min-height: 30px;"
                "} "
                "KeyboardButton:hover {"
                "    border-color: #888888;"
                "    background-color: rgb(73, 70, 67);"
                "} "
                "KeyboardButton:pressed {"
                "    border-color: #aaaaaa;"
                "    background-color: rgb(33, 30, 27);"
                "}"
            );
        }
    }
}

void TouchKeyboard::checkInputContent()
{
    // 检查输入框内容是否发生变化
    QString currentText;
    if (m_targetInputInterface) {
        currentText = m_targetInputInterface->text();
    } else if (m_targetInput) {
        currentText = m_targetInput->text();
    } else if (m_targetTextEdit) {
        currentText = m_targetTextEdit->toPlainText();
    }
    
    if (currentText != m_lastInputText) {
        m_lastInputText = currentText;
        updateEnterButtonState();
    }
}


bool TouchKeyboard::eventFilter(QObject *obj, QEvent *event)
{
    // 优化：只处理必要的事件，减少不必要的处理
    if (obj->objectName() == "dragHintLabel") {
        switch (event->type()) {
        case QEvent::Enter:
            // 鼠标进入拖拽提示标签时，改变标题栏背景色
            if (QWidget *headerWidget = findChild<QWidget*>("headerWidget")) {
                headerWidget->setStyleSheet(
                    "#headerWidget {"
                    "    background-color: rgb(65, 62, 59);"  // 悬停时的背景色
                    "    border: none;"
                    "    border-radius: 4px;"
                    "    margin: 2px 2px 0px 2px;"
                    "}"
                );
            }
            return false;
        case QEvent::Leave:
            // 鼠标离开拖拽提示标签时，恢复标题栏背景色
            if (QWidget *headerWidget = findChild<QWidget*>("headerWidget")) {
                headerWidget->setStyleSheet(
                    "#headerWidget {"
                    "    background-color: rgb(53, 50, 47);"  // 默认背景色
                    "    border: none;"
                    "    border-radius: 4px;"
                    "    margin: 2px 2px 0px 2px;"
                    "}"
                );
            }
            return false;
        default:
            break;
        }
    }
    
    // 调用基类的事件过滤器
    return QWidget::eventFilter(obj, event);
}

bool TouchKeyboard::event(QEvent *event)
{
    // 优化：只处理必要的事件类型
    switch (event->type()) {
    case QEvent::TouchBegin:
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd:
        touchEvent(static_cast<QTouchEvent*>(event));
        return true;
    default:
        break;
    }
    
    // 调用基类的事件处理函数
    return QWidget::event(event);
}

void TouchKeyboard::enterEvent(QEvent *event)
{
    // 鼠标进入窗口事件处理
    QWidget::enterEvent(event);
}

void TouchKeyboard::leaveEvent(QEvent *event)
{
    // 鼠标离开窗口事件处理
    QWidget::leaveEvent(event);
}
